package cn.tedu.eb_film.service.impl;

import cn.tedu.eb_film.ex.ServiceException;
import cn.tedu.eb_film.mapper.MovieTypeMapper;
import cn.tedu.eb_film.pojo.dto.MovieTypeAddDTO;
import cn.tedu.eb_film.pojo.dto.MovieTypeUpdateDTO;
import cn.tedu.eb_film.pojo.entity.Movie;
import cn.tedu.eb_film.pojo.entity.MovieType;
import cn.tedu.eb_film.pojo.vo.MovieListVO;
import cn.tedu.eb_film.pojo.vo.MovieStandardVO;
import cn.tedu.eb_film.pojo.vo.MovieTypeListVO;
import cn.tedu.eb_film.pojo.vo.MovieTypeStandardVO;
import cn.tedu.eb_film.service.MovieTypeService;
import cn.tedu.eb_film.utils.ServiceCode;
import cn.tedu.eb_film.utils.StateCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * @author tarena
 */

@Service
@Slf4j
public class MovieTypeServiceImpl implements MovieTypeService {
    @Autowired
    private MovieTypeMapper movieTypeMapper;

    @Override
    public void addNew(MovieTypeAddDTO movieTypeAddDTO) {
     log.debug("即将处理【新增电影类型】功能，参数：{}",movieTypeAddDTO);
        //根据id查询电影类型数据
        int count = movieTypeMapper.countByName(movieTypeAddDTO.getName());
       //判断电影类型是否存在
        if (count == 1){
            //存在，抛出异常
            String message ="添加电影类型失败，电影类型已存在";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
        }
        //创建实体类
        MovieType movieType = new MovieType();
        //将movieTypeAddDTO赋值给movieType
        BeanUtils.copyProperties(movieTypeAddDTO,movieType);
        movieType.setCreateTime(LocalDateTime.now());
        int row = movieTypeMapper.insert(movieType);
        if (row != 1){
            String message ="添加电影类型失败，服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT,message);
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void insetBash(List<MovieTypeAddDTO> movieTypeAddDTO) {
        log.debug("即将处理【批量新增电影类型】功能，参数：{}",movieTypeAddDTO);
        //创建List<MovieType>集合
        List<MovieType> movieTypes = new ArrayList<>();
        for (MovieTypeAddDTO typeAddDTO : movieTypeAddDTO) {
            //根据id查询电影类型数据
            int count = movieTypeMapper.countByName(typeAddDTO.getName());
            //判断电影类型是否存在
            if (count == 1){
                //存在，抛出异常
                String message ="添加电影类型失败，电影类型已存在";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_CONFLICT,message);
            }
            //创建实体类
            MovieType movieType = new MovieType();
            //将typeAddDTO赋值给movieType
            BeanUtils.copyProperties(typeAddDTO,movieType);
            movieType.setCreateTime(LocalDateTime.now());
            movieTypes.add(movieType);
        }

        int row = movieTypeMapper.insertBatch(movieTypes);
        if (row != movieTypes.size()){
            String message ="批量添加电影类型失败，服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT,message);
        }
    }

    @Override
    public void deleteById(Integer id) {
        log.debug("即将处理【删除电影类型】功能，参数id：{}",id);
        //判断删除的id是否存在
        MovieTypeStandardVO movieType = movieTypeMapper.getStandardById(id);
        if (movieType == null){
            //为空
            String message ="删除电影类型失败，电影类型不存在";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        int row = movieTypeMapper.deleteById(id);
        if (row != 1){
            String message ="删除电影类型失败，服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE,message);
        }


    }

    @Override
    public void updateInfoById(Integer id, MovieTypeUpdateDTO movieTypeUpdateDTO) {
        log.debug("开始处理【修改电影类型数据】的业务，id：{}，movieTypeUpdateDTO:{}",id,movieTypeUpdateDTO);
        //调用movieMapper对象的getStandardId()方法查询
        MovieTypeStandardVO queryResult = movieTypeMapper.getStandardById(id);
        //判断是否为空
        if (queryResult == null){
            //为空
            String message ="修改电影类型失败，该电影类型不存在";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }

        //调用movieTypeMapper对象的countByNameAndNotId()方法
        int count = movieTypeMapper.countByNameAndNotId(id, movieTypeUpdateDTO.getName());
        if (count != 0){
            //不为0，则名称重复
            String message = "修改电影类型详情失败，电影类型名称已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }
        //创建实体类movie
        MovieType movieType = new MovieType();
        //将movieTypeUpdateDTO复制给movieType
        BeanUtils.copyProperties(movieTypeUpdateDTO,movieType);
        movieType.setId(id);
        //修改电影数据
        int row = movieTypeMapper.update(movieType);
        if (row != 1){
            String message ="修改电影类型失败，服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE,message);
        }

    }

    @Override
    public void setEnable(Integer id) {
        log.debug("开始处理【启用电影类型】的业务，参数：{}", id);
        updateEnableById(id, 1);
    }

    @Override
    public void setDisable(Integer id) {
        log.debug("开始处理【禁用电影类型】的业务，参数：{}", id);
        updateEnableById(id, 0);
    }

    private void updateEnableById(Integer id, Integer enable) {
        // 调用Mapper对象的getStandardById()方法执行查询
        MovieTypeStandardVO currentMovie = movieTypeMapper.getStandardById(id);
        // 判断查询结果是否为null，如果是，则抛出异常
        if (currentMovie == null) {
            String message = ENABLE_TEXT[enable] + "电影类型失败，电影类型数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        // 判断查询结果中的enable与参数enable是否相同，如果是，则抛出异常（当前状态与目标状态相同，没必要执行更新）
        if (currentMovie.getState().equals(enable)) {
            String message = ENABLE_TEXT[enable] + "电影类型失败，此电影类型已经处于" + ENABLE_TEXT[enable] + "状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 创建MovieType对象
        MovieType updateMovieType = new MovieType();
        // 向updateMovieType对象中封装属性值：id, enable，均来自方法参数
        updateMovieType.setId(id);
        updateMovieType.setState(enable);
        System.out.println("updateMovieType"+updateMovieType);
        // 调用Mapper对象的update()方法执行更新
        int rows = movieTypeMapper.update(updateMovieType);
        if (rows != 1) {
            String message = ENABLE_TEXT[enable] + "电影类型失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    @Override
    public MovieTypeStandardVO getStandardById(Integer id) {
        log.debug("开始处理【根据id查询电影类型数据】的业务，id：{}",id);
        MovieTypeStandardVO movieType = movieTypeMapper.getStandardById(id);
        if (movieType == null){
            String message ="查询电影详情失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND,message);
        }
        return movieType;
    }


    @Override
    public List<MovieTypeListVO> list() {
        log.debug("开始处理【按照时间前后查询电影】的业务,无参数");
        return movieTypeMapper.list();
    }

    @Override
    public List<MovieTypeListVO> listSearch(String name) {
        log.debug("开始处理【按照搜索条件查询电影】的业务,name：{}",name);
        return movieTypeMapper.listSearch(name);
    }
}
